import { Router, Request, Response } from 'express';
import jwt from 'jsonwebtoken';
import bcrypt from 'bcryptjs';


const router = Router();

// 声明环境变量类型
declare global {
  namespace NodeJS {
    interface ProcessEnv {
      JWT_SECRET?: string;
    }
  }
}

// 确保JWT密钥是字符串类型
const JWT_SECRET: string = process.env.JWT_SECRET ?? 'zhunong-admin-secret';

// 存储注册的管理员列表（实际应用中应存储在数据库中）
const adminUsers: any[] = [
  {
    id: '1',
    username: 'admin',
    password: '123456', // 实际应用中应存储加密后的密码
    realName: '超级管理员',
    email: 'admin@example.com',
    phone: '13800138000',
    role: 'admin',
    status: 'active',
    permissions: ['*'],
    createdAt: new Date().toISOString()
  }
];

// 管理员登录接口
router.post('/login', async (req: Request, res: Response) => {
  try {
    const { username, password } = req.body;

    // 从管理员列表中查找用户
    const admin = adminUsers.find(user => user.username === username);
    if (!admin) {
      return res.status(400).json({
        code: 400,
        message: '用户名不存在',
        data: null
      });
    }

    // 验证密码
    let isPasswordValid = false;
    
    // 如果密码是加密的，使用bcrypt比较
    if (admin.password.startsWith('$2')) {
      isPasswordValid = await bcrypt.compare(password, admin.password);
    } else {
      // 为了兼容硬编码的明文密码（仅用于演示）
      isPasswordValid = password === admin.password;
    }

    if (!isPasswordValid) {
      return res.status(400).json({
        code: 400,
        message: '密码错误',
        data: null
      });
    }

    // 生成JWT令牌
    const tokenPayload = { 
      id: admin.id, 
      username: admin.username, 
      role: admin.role 
    };
    // @ts-ignore - 绕过TypeScript检查
    const token = jwt.sign(tokenPayload, process.env.JWT_SECRET || 'zhunong-admin-secret', { expiresIn: '24h' });

    // 返回登录成功响应
    return res.json({
      code: 200,
      message: '登录成功',
      data: {
        token
      }
    });
  } catch (error) {
    console.error('管理员登录失败:', error);
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误',
      data: null
    });
  }
});

// 获取管理员信息
router.get('/info', async (req: Request, res: Response) => {
  try {
    // 从请求头获取Token
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({
        code: 401,
        message: '未授权，请先登录',
        data: null
      });
    }

    const token = authHeader.split(' ')[1];
    
    try {
      // @ts-ignore - 绕过TypeScript检查
      const decoded = jwt.verify(token, process.env.JWT_SECRET || 'zhunong-admin-secret');
      const userId = (decoded as any)?.id;
      
      // 从管理员列表中查找用户
      const admin = adminUsers.find(user => user.id === userId);
      
      if (!admin) {
        throw new Error('用户不存在');
      }
      
      // 返回管理员信息（不包含密码）
      const { password: _, ...adminInfo } = admin;
      
      // 构建响应格式以兼容前端预期
      const formattedAdminInfo = {
        ...adminInfo,
        role: {
          id: '1',
          name: adminInfo.role === 'superadmin' ? '超级管理员' : '管理员',
          permissions: adminInfo.permissions,
          createdAt: adminInfo.createdAt,
          updatedAt: adminInfo.createdAt
        }
      };

      return res.json({
        code: 200,
        message: '获取管理员信息成功',
        data: formattedAdminInfo
      });
    } catch (jwtError) {
      console.error('Token验证失败:', jwtError);
      return res.status(401).json({
        code: 401,
        message: '无效的Token',
        data: null
      });
    }
  } catch (error) {
    console.error('获取管理员信息失败:', error);
    return res.status(401).json({
      code: 401,
      message: '服务器错误',
      data: null
    });
  }
});

// 管理员退出登录
router.post('/logout', (req: Request, res: Response) => {
  // 客户端负责清除Token，服务端只需返回成功响应
  return res.json({
    code: 200,
    message: '退出登录成功',
    data: null
  });
});

export default router; 